/**
 * 头像缓存工具类
 * 用于缓存用户头像，避免重复加载，提升IM界面性能
 */

class AvatarCache {
    constructor() {
        // 头像缓存 {key: {url: string, timestamp: number, type: string}}
        // key格式: user_${userId} 或 group_${groupId}，确保用户和群聊头像不会混淆
        this.cache = new Map();
        // 缓存过期时间（30分钟）
        this.expireTime = 30 * 60 * 1000;
        // 预加载的头像队列
        this.preloadQueue = new Set();
        // 正在加载的头像
        this.loading = new Set();
    }

    /**
     * 生成缓存键
     * @param {number|string} id - ID
     * @param {string} type - 类型 'user' 或 'group'
     * @returns {string} 缓存键
     */
    generateCacheKey(id, type = 'user') {
        return `${type}_${id}`;
    }

    /**
     * 获取头像URL
     * @param {number|string} id - 用户ID或群组ID
     * @param {string} type - 类型 'user' 或 'group'
     * @param {string} defaultUrl - 默认头像URL
     * @returns {string} 头像URL
     */
    getAvatar(id, type = 'user', defaultUrl = '') {
        if (!id) return defaultUrl;

        const cacheKey = this.generateCacheKey(id, type);
        const cached = this.cache.get(cacheKey);
        if (cached && this.isValid(cached)) {
            return cached.url || defaultUrl;
        }

        return defaultUrl;
    }

    /**
     * 立即获取头像URL，如果缓存中没有则返回空字符串
     * @param {number|string} id - 用户ID或群组ID
     * @param {string} type - 类型 'user' 或 'group'
     * @returns {string} 头像URL或空字符串
     */
    getAvatarImmediate(id, type = 'user') {
        if (!id) return '';

        const cacheKey = this.generateCacheKey(id, type);
        const cached = this.cache.get(cacheKey);
        if (cached && this.isValid(cached)) {
            return cached.url || '';
        }

        return '';
    }

    /**
     * 设置头像缓存
     * @param {number|string} id - 用户ID或群组ID
     * @param {string} url - 头像URL
     * @param {string} type - 类型 'user' 或 'group'
     */
    setAvatar(id, url, type = 'user') {
        if (!id) return;

        const cacheKey = this.generateCacheKey(id, type);
        this.cache.set(cacheKey, {
            url: url || '',
            timestamp: Date.now(),
            type: type
        });
    }

    /**
     * 批量设置头像缓存
     * @param {Array} items - 用户或群组列表 [{userId/id, headImage, type?}]
     * @param {string} defaultType - 默认类型 'user' 或 'group'
     */
    batchSetAvatars(items, defaultType = 'user') {
        if (!Array.isArray(items)) return;

        items.forEach(item => {
            if (item.userId || item.id) {
                const id = item.userId || item.id;
                const headImage = item.headImage || item.headImageThumb || '';
                const type = item.type || defaultType;
                // 只有当头像URL存在时才缓存，避免缓存空头像覆盖默认显示
                if (headImage) {
                    this.setAvatar(id, headImage, type);
                }
            }
        });
    }

    /**
     * 预加载头像
     * @param {string} url - 头像URL
     * @returns {Promise} 加载Promise
     */
    preloadAvatar(url) {
        if (!url || this.preloadQueue.has(url) || this.loading.has(url)) {
            return Promise.resolve();
        }

        this.loading.add(url);
        this.preloadQueue.add(url);

        return new Promise((resolve, reject) => {
            const img = new Image();

            img.onload = () => {
                this.loading.delete(url);
                console.log(`头像预加载成功: ${url}`);
                resolve();
            };

            img.onerror = () => {
                this.loading.delete(url);
                this.preloadQueue.delete(url);
                console.warn(`头像预加载失败: ${url}`);
                reject(new Error(`Failed to preload avatar: ${url}`));
            };

            img.src = url;
        });
    }

    /**
     * 批量预加载头像
     * @param {Array} urls - 头像URL列表
     * @returns {Promise} 加载Promise
     */
    async batchPreloadAvatars(urls) {
        if (!Array.isArray(urls)) return;

        const validUrls = urls.filter(url => url && typeof url === 'string');
        if (validUrls.length === 0) return;

        console.log(`开始批量预加载 ${validUrls.length} 个头像`);

        const promises = validUrls.map(url =>
            this.preloadAvatar(url).catch(error => {
                console.warn(`头像预加载失败: ${url}`, error);
                return null; // 不让单个失败影响整体
            })
        );

        try {
            await Promise.allSettled(promises);
            console.log(`头像批量预加载完成`);
        } catch (error) {
            console.error('头像批量预加载出错:', error);
        }
    }

    /**
     * 从用户列表中提取并预加载头像
     * @param {Array} items - 用户或群组列表
     * @param {string} type - 类型 'user' 或 'group'
     */
    async preloadAvatarsFromItems(items, type = 'user') {
        if (!Array.isArray(items)) return;

        const avatarUrls = items
            .map(item => item.headImage || item.headImageThumb)
            .filter(url => url && typeof url === 'string');

        if (avatarUrls.length > 0) {
            await this.batchPreloadAvatars(avatarUrls);
            // 同时缓存头像信息，只缓存有真实头像URL的项目
            this.batchSetAvatars(items, type);
        }
    }

    /**
     * 从用户列表中提取并预加载头像（保持向后兼容）
     * @param {Array} users - 用户列表
     */
    async preloadAvatarsFromUsers(users) {
        return this.preloadAvatarsFromItems(users, 'user');
    }

    /**
     * 检查缓存是否有效
     * @param {object} cached - 缓存对象
     * @returns {boolean} 是否有效
     */
    isValid(cached) {
        return cached && (Date.now() - cached.timestamp) < this.expireTime;
    }

    /**
     * 清理过期缓存
     */
    cleanExpired() {
        for (const [cacheKey, cached] of this.cache.entries()) {
            if (!this.isValid(cached)) {
                this.cache.delete(cacheKey);
            }
        }
        console.log(`清理过期头像缓存完成，当前缓存数量: ${this.cache.size}`);
    }

    /**
     * 清空所有缓存
     */
    clear() {
        this.cache.clear();
        this.preloadQueue.clear();
        this.loading.clear();
        console.log('头像缓存已清空');
    }

    /**
     * 清理指定类型的缓存
     * @param {string} type - 要清理的类型 'user' 或 'group'
     */
    clearByType(type) {
        const keysToDelete = [];
        for (const cacheKey of this.cache.keys()) {
            if (cacheKey.startsWith(`${type}_`)) {
                keysToDelete.push(cacheKey);
            }
        }
        keysToDelete.forEach(key => this.cache.delete(key));
        console.log(`清理${type}类型头像缓存完成，清理数量: ${keysToDelete.length}`);
    }

    /**
     * 删除指定ID和类型的缓存
     * @param {number|string} id - ID
     * @param {string} type - 类型 'user' 或 'group'
     */
    removeAvatar(id, type = 'user') {
        if (!id) return;
        const cacheKey = this.generateCacheKey(id, type);
        this.cache.delete(cacheKey);
    }

    /**
     * 获取缓存统计信息
     * @returns {object} 统计信息
     */
    getStats() {
        return {
            cacheSize: this.cache.size,
            preloadQueueSize: this.preloadQueue.size,
            loadingSize: this.loading.size
        };
    }
}

// 创建全局单例
const avatarCache = new AvatarCache();

// 定期清理过期缓存（每10分钟）
setInterval(() => {
    avatarCache.cleanExpired();
}, 10 * 60 * 1000);

export default avatarCache;
